+Thu Nov 15 14:19:34 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gdk/gdkwindow.c (gdk_window_invalidate_maybe_recurse): Cal
+ gdk_window_invalidate_maybe_recurse() for recursion.
+ (Soeren Sandmann)
+
+ * gtk/gtkviewport.c: Make !redraw_on_allocate. (Soeren Sandmann)
+
+ * gtk/gtkcontainer.c (gtk_container_expose): Call
+ gtk_container_forall() not _foreach() to propagate,
+ since we need to propagate exposes to internal children
+ as well.
+
+ * gtk/gtkwidget.c (gtk_widget_set_events, gtk_widget_add_events):
+ Remove the restriction of only being able to call these
+ on window widgets, since we have lots of NO_WINDOW widgets
+ with windows now; for add events, recurse over the children
+ of widget->window to find one owned by the widget.
+
+ * gtk/gtkbutton.[ch]: Make a NO_WINDOW widget, using an input-only
+ window to catch events.
+
+ * gtk/gtktogglebutton.[ch]: Remove the code for switching
+ between NO_WINDOW and WINDOW widgets based on the mode.
+
+ * gtk/gtkcheckbutton.c gtk/gtkoptionmenu.c gtk/gtkclist.c
+ gtk/gtktreeview.c: Adopt to NO_WINDOW change for GtkButton.
+
+ * gtk/gtkrange.[ch]: Make into a NO_WINDOW widget.
+
+ * gtk/gtkhscale.c, gtk/gtkvscale.c: Adopt to NO_WINDOW
+ change for range.
+
+ * gtk/gtknotebook.[ch]: Make into a NO_WINDOW widget.
+
+ * docs/Changes-2.0.txt: Add a note about the NO_WINDOW changes.
+
Thu Nov 15 11:59:35 2001 Owen Taylor <otaylor@redhat.com>
* gtk/gtkmessagedialog.c: Patch from Murray Cumming to add
+Thu Nov 15 14:19:34 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gdk/gdkwindow.c (gdk_window_invalidate_maybe_recurse): Cal
+ gdk_window_invalidate_maybe_recurse() for recursion.
+ (Soeren Sandmann)
+
+ * gtk/gtkviewport.c: Make !redraw_on_allocate. (Soeren Sandmann)
+
+ * gtk/gtkcontainer.c (gtk_container_expose): Call
+ gtk_container_forall() not _foreach() to propagate,
+ since we need to propagate exposes to internal children
+ as well.
+
+ * gtk/gtkwidget.c (gtk_widget_set_events, gtk_widget_add_events):
+ Remove the restriction of only being able to call these
+ on window widgets, since we have lots of NO_WINDOW widgets
+ with windows now; for add events, recurse over the children
+ of widget->window to find one owned by the widget.
+
+ * gtk/gtkbutton.[ch]: Make a NO_WINDOW widget, using an input-only
+ window to catch events.
+
+ * gtk/gtktogglebutton.[ch]: Remove the code for switching
+ between NO_WINDOW and WINDOW widgets based on the mode.
+
+ * gtk/gtkcheckbutton.c gtk/gtkoptionmenu.c gtk/gtkclist.c
+ gtk/gtktreeview.c: Adopt to NO_WINDOW change for GtkButton.
+
+ * gtk/gtkrange.[ch]: Make into a NO_WINDOW widget.
+
+ * gtk/gtkhscale.c, gtk/gtkvscale.c: Adopt to NO_WINDOW
+ change for range.
+
+ * gtk/gtknotebook.[ch]: Make into a NO_WINDOW widget.
+
+ * docs/Changes-2.0.txt: Add a note about the NO_WINDOW changes.
+
Thu Nov 15 11:59:35 2001 Owen Taylor <otaylor@redhat.com>
* gtk/gtkmessagedialog.c: Patch from Murray Cumming to add
+Thu Nov 15 14:19:34 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gdk/gdkwindow.c (gdk_window_invalidate_maybe_recurse): Cal
+ gdk_window_invalidate_maybe_recurse() for recursion.
+ (Soeren Sandmann)
+
+ * gtk/gtkviewport.c: Make !redraw_on_allocate. (Soeren Sandmann)
+
+ * gtk/gtkcontainer.c (gtk_container_expose): Call
+ gtk_container_forall() not _foreach() to propagate,
+ since we need to propagate exposes to internal children
+ as well.
+
+ * gtk/gtkwidget.c (gtk_widget_set_events, gtk_widget_add_events):
+ Remove the restriction of only being able to call these
+ on window widgets, since we have lots of NO_WINDOW widgets
+ with windows now; for add events, recurse over the children
+ of widget->window to find one owned by the widget.
+
+ * gtk/gtkbutton.[ch]: Make a NO_WINDOW widget, using an input-only
+ window to catch events.
+
+ * gtk/gtktogglebutton.[ch]: Remove the code for switching
+ between NO_WINDOW and WINDOW widgets based on the mode.
+
+ * gtk/gtkcheckbutton.c gtk/gtkoptionmenu.c gtk/gtkclist.c
+ gtk/gtktreeview.c: Adopt to NO_WINDOW change for GtkButton.
+
+ * gtk/gtkrange.[ch]: Make into a NO_WINDOW widget.
+
+ * gtk/gtkhscale.c, gtk/gtkvscale.c: Adopt to NO_WINDOW
+ change for range.
+
+ * gtk/gtknotebook.[ch]: Make into a NO_WINDOW widget.
+
+ * docs/Changes-2.0.txt: Add a note about the NO_WINDOW changes.
+
Thu Nov 15 11:59:35 2001 Owen Taylor <otaylor@redhat.com>
* gtk/gtkmessagedialog.c: Patch from Murray Cumming to add
+Thu Nov 15 14:19:34 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gdk/gdkwindow.c (gdk_window_invalidate_maybe_recurse): Cal
+ gdk_window_invalidate_maybe_recurse() for recursion.
+ (Soeren Sandmann)
+
+ * gtk/gtkviewport.c: Make !redraw_on_allocate. (Soeren Sandmann)
+
+ * gtk/gtkcontainer.c (gtk_container_expose): Call
+ gtk_container_forall() not _foreach() to propagate,
+ since we need to propagate exposes to internal children
+ as well.
+
+ * gtk/gtkwidget.c (gtk_widget_set_events, gtk_widget_add_events):
+ Remove the restriction of only being able to call these
+ on window widgets, since we have lots of NO_WINDOW widgets
+ with windows now; for add events, recurse over the children
+ of widget->window to find one owned by the widget.
+
+ * gtk/gtkbutton.[ch]: Make a NO_WINDOW widget, using an input-only
+ window to catch events.
+
+ * gtk/gtktogglebutton.[ch]: Remove the code for switching
+ between NO_WINDOW and WINDOW widgets based on the mode.
+
+ * gtk/gtkcheckbutton.c gtk/gtkoptionmenu.c gtk/gtkclist.c
+ gtk/gtktreeview.c: Adopt to NO_WINDOW change for GtkButton.
+
+ * gtk/gtkrange.[ch]: Make into a NO_WINDOW widget.
+
+ * gtk/gtkhscale.c, gtk/gtkvscale.c: Adopt to NO_WINDOW
+ change for range.
+
+ * gtk/gtknotebook.[ch]: Make into a NO_WINDOW widget.
+
+ * docs/Changes-2.0.txt: Add a note about the NO_WINDOW changes.
+
Thu Nov 15 11:59:35 2001 Owen Taylor <otaylor@redhat.com>
* gtk/gtkmessagedialog.c: Patch from Murray Cumming to add
+Thu Nov 15 14:19:34 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gdk/gdkwindow.c (gdk_window_invalidate_maybe_recurse): Cal
+ gdk_window_invalidate_maybe_recurse() for recursion.
+ (Soeren Sandmann)
+
+ * gtk/gtkviewport.c: Make !redraw_on_allocate. (Soeren Sandmann)
+
+ * gtk/gtkcontainer.c (gtk_container_expose): Call
+ gtk_container_forall() not _foreach() to propagate,
+ since we need to propagate exposes to internal children
+ as well.
+
+ * gtk/gtkwidget.c (gtk_widget_set_events, gtk_widget_add_events):
+ Remove the restriction of only being able to call these
+ on window widgets, since we have lots of NO_WINDOW widgets
+ with windows now; for add events, recurse over the children
+ of widget->window to find one owned by the widget.
+
+ * gtk/gtkbutton.[ch]: Make a NO_WINDOW widget, using an input-only
+ window to catch events.
+
+ * gtk/gtktogglebutton.[ch]: Remove the code for switching
+ between NO_WINDOW and WINDOW widgets based on the mode.
+
+ * gtk/gtkcheckbutton.c gtk/gtkoptionmenu.c gtk/gtkclist.c
+ gtk/gtktreeview.c: Adopt to NO_WINDOW change for GtkButton.
+
+ * gtk/gtkrange.[ch]: Make into a NO_WINDOW widget.
+
+ * gtk/gtkhscale.c, gtk/gtkvscale.c: Adopt to NO_WINDOW
+ change for range.
+
+ * gtk/gtknotebook.[ch]: Make into a NO_WINDOW widget.
+
+ * docs/Changes-2.0.txt: Add a note about the NO_WINDOW changes.
+
Thu Nov 15 11:59:35 2001 Owen Taylor <otaylor@redhat.com>
* gtk/gtkmessagedialog.c: Patch from Murray Cumming to add
+Thu Nov 15 14:19:34 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gdk/gdkwindow.c (gdk_window_invalidate_maybe_recurse): Cal
+ gdk_window_invalidate_maybe_recurse() for recursion.
+ (Soeren Sandmann)
+
+ * gtk/gtkviewport.c: Make !redraw_on_allocate. (Soeren Sandmann)
+
+ * gtk/gtkcontainer.c (gtk_container_expose): Call
+ gtk_container_forall() not _foreach() to propagate,
+ since we need to propagate exposes to internal children
+ as well.
+
+ * gtk/gtkwidget.c (gtk_widget_set_events, gtk_widget_add_events):
+ Remove the restriction of only being able to call these
+ on window widgets, since we have lots of NO_WINDOW widgets
+ with windows now; for add events, recurse over the children
+ of widget->window to find one owned by the widget.
+
+ * gtk/gtkbutton.[ch]: Make a NO_WINDOW widget, using an input-only
+ window to catch events.
+
+ * gtk/gtktogglebutton.[ch]: Remove the code for switching
+ between NO_WINDOW and WINDOW widgets based on the mode.
+
+ * gtk/gtkcheckbutton.c gtk/gtkoptionmenu.c gtk/gtkclist.c
+ gtk/gtktreeview.c: Adopt to NO_WINDOW change for GtkButton.
+
+ * gtk/gtkrange.[ch]: Make into a NO_WINDOW widget.
+
+ * gtk/gtkhscale.c, gtk/gtkvscale.c: Adopt to NO_WINDOW
+ change for range.
+
+ * gtk/gtknotebook.[ch]: Make into a NO_WINDOW widget.
+
+ * docs/Changes-2.0.txt: Add a note about the NO_WINDOW changes.
+
Thu Nov 15 11:59:35 2001 Owen Taylor <otaylor@redhat.com>
* gtk/gtkmessagedialog.c: Patch from Murray Cumming to add
+Thu Nov 15 14:19:34 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gdk/gdkwindow.c (gdk_window_invalidate_maybe_recurse): Cal
+ gdk_window_invalidate_maybe_recurse() for recursion.
+ (Soeren Sandmann)
+
+ * gtk/gtkviewport.c: Make !redraw_on_allocate. (Soeren Sandmann)
+
+ * gtk/gtkcontainer.c (gtk_container_expose): Call
+ gtk_container_forall() not _foreach() to propagate,
+ since we need to propagate exposes to internal children
+ as well.
+
+ * gtk/gtkwidget.c (gtk_widget_set_events, gtk_widget_add_events):
+ Remove the restriction of only being able to call these
+ on window widgets, since we have lots of NO_WINDOW widgets
+ with windows now; for add events, recurse over the children
+ of widget->window to find one owned by the widget.
+
+ * gtk/gtkbutton.[ch]: Make a NO_WINDOW widget, using an input-only
+ window to catch events.
+
+ * gtk/gtktogglebutton.[ch]: Remove the code for switching
+ between NO_WINDOW and WINDOW widgets based on the mode.
+
+ * gtk/gtkcheckbutton.c gtk/gtkoptionmenu.c gtk/gtkclist.c
+ gtk/gtktreeview.c: Adopt to NO_WINDOW change for GtkButton.
+
+ * gtk/gtkrange.[ch]: Make into a NO_WINDOW widget.
+
+ * gtk/gtkhscale.c, gtk/gtkvscale.c: Adopt to NO_WINDOW
+ change for range.
+
+ * gtk/gtknotebook.[ch]: Make into a NO_WINDOW widget.
+
+ * docs/Changes-2.0.txt: Add a note about the NO_WINDOW changes.
+
Thu Nov 15 11:59:35 2001 Owen Taylor <otaylor@redhat.com>
* gtk/gtkmessagedialog.c: Patch from Murray Cumming to add
If you want to actually draw contents in a widget derived from
one of these widgets, you'll probably want to change this
in your init() function.
+
+* A number of widgets are now NO_WINDOW widgets (most importantly
+ GtkButton, but also GtkRange and GtkNotebook)
+
+ This has a couple of effects:
+
+ - If you are deriving from one of these widgets, you need to
+ adapt your code appropriately -- for instance, drawing coordinates
+ start from widget->allocation.x, widget->allocation.y.
+
+ - If you are embedding one of these widgets in a custom widget,
+ you must make sure you call gtk_container_propagate_expose()
+ correctly, as you must for any NO_WINDOW widgets.
+
GParamSpec *pspec);
static void gtk_button_realize (GtkWidget *widget);
static void gtk_button_unrealize (GtkWidget *widget);
+static void gtk_button_map (GtkWidget *widget);
+static void gtk_button_unmap (GtkWidget *widget);
static void gtk_button_size_request (GtkWidget *widget,
GtkRequisition *requisition);
static void gtk_button_size_allocate (GtkWidget *widget,
widget_class->realize = gtk_button_realize;
widget_class->unrealize = gtk_button_unrealize;
+ widget_class->map = gtk_button_map;
+ widget_class->unmap = gtk_button_unmap;
widget_class->size_request = gtk_button_size_request;
widget_class->size_allocate = gtk_button_size_allocate;
widget_class->expose_event = gtk_button_expose;
gtk_button_init (GtkButton *button)
{
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_FOCUS | GTK_RECEIVES_DEFAULT);
- GTK_WIDGET_UNSET_FLAGS (button, GTK_NO_WINDOW);
+ GTK_WIDGET_SET_FLAGS (button, GTK_NO_WINDOW);
button->label_text = NULL;
attributes.y = widget->allocation.y + border_width;
attributes.width = widget->allocation.width - border_width * 2;
attributes.height = widget->allocation.height - border_width * 2;
- attributes.wclass = GDK_INPUT_OUTPUT;
- attributes.visual = gtk_widget_get_visual (widget);
- attributes.colormap = gtk_widget_get_colormap (widget);
+ attributes.wclass = GDK_INPUT_ONLY;
attributes.event_mask = gtk_widget_get_events (widget);
attributes.event_mask |= (GDK_EXPOSURE_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_ENTER_NOTIFY_MASK |
GDK_LEAVE_NOTIFY_MASK);
- attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+ attributes_mask = GDK_WA_X | GDK_WA_Y;
- widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
- gdk_window_set_user_data (widget->window, button);
+ widget->window = gtk_widget_get_parent_window (widget);
+ gdk_window_ref (widget->window);
+
+ button->event_window = gdk_window_new (gtk_widget_get_parent_window (widget),
+ &attributes, attributes_mask);
+ gdk_window_set_user_data (button->event_window, button);
widget->style = gtk_style_attach (widget->style, widget->window);
- gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
}
static void
if (button->activate_timeout)
gtk_button_finish_activate (button, FALSE);
-
+
+ if (button->event_window)
+ {
+ gdk_window_set_user_data (button->event_window, NULL);
+ gdk_window_destroy (button->event_window);
+ button->event_window = NULL;
+ }
+
GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
}
+static void
+gtk_button_map (GtkWidget *widget)
+{
+ GtkButton *button = GTK_BUTTON (widget);
+
+ g_return_if_fail (GTK_IS_BUTTON (widget));
+
+ if (button->event_window)
+ gdk_window_show (button->event_window);
+
+ GTK_WIDGET_CLASS (parent_class)->map (widget);
+}
+
+static void
+gtk_button_unmap (GtkWidget *widget)
+{
+ GtkButton *button = GTK_BUTTON (widget);
+
+ g_return_if_fail (GTK_IS_BUTTON (widget));
+
+ if (button->event_window)
+ gdk_window_hide (button->event_window);
+
+ GTK_WIDGET_CLASS (parent_class)->unmap (widget);
+}
+
static void
gtk_button_get_props (GtkButton *button,
GtkBorder *default_border,
widget->allocation = *allocation;
if (GTK_WIDGET_REALIZED (widget))
- gdk_window_move_resize (widget->window,
+ gdk_window_move_resize (button->event_window,
widget->allocation.x + border_width,
widget->allocation.y + border_width,
widget->allocation.width - border_width * 2,
if (GTK_BIN (button)->child && GTK_WIDGET_VISIBLE (GTK_BIN (button)->child))
{
- child_allocation.x = (CHILD_SPACING + xthickness);
- child_allocation.y = (CHILD_SPACING + ythickness);
+ child_allocation.x = widget->allocation.x + border_width + (CHILD_SPACING + xthickness);
+ child_allocation.y = widget->allocation.y + border_width + (CHILD_SPACING + ythickness);
- child_allocation.width = MAX (1, (gint)widget->allocation.width - child_allocation.x * 2 -
+ child_allocation.width = MAX (1, (gint)widget->allocation.width - (CHILD_SPACING + xthickness) * 2 -
border_width * 2);
- child_allocation.height = MAX (1, (gint)widget->allocation.height - child_allocation.y * 2 -
+ child_allocation.height = MAX (1, (gint)widget->allocation.height - (CHILD_SPACING + ythickness) * 2 -
border_width * 2);
if (GTK_WIDGET_CAN_DEFAULT (button))
GtkShadowType shadow_type;
gint width, height;
gint x, y;
+ gint border_width;
GtkBorder default_border;
GtkBorder default_outside_border;
gboolean interior_focus;
if (GTK_WIDGET_DRAWABLE (widget))
{
+ border_width = GTK_CONTAINER (widget)->border_width;
button = GTK_BUTTON (widget);
gtk_button_get_props (button, &default_border, &default_outside_border, &interior_focus);
- x = 0;
- y = 0;
- width = widget->allocation.width - GTK_CONTAINER (widget)->border_width * 2;
- height = widget->allocation.height - GTK_CONTAINER (widget)->border_width * 2;
-
- gdk_window_set_back_pixmap (widget->window, NULL, TRUE);
- gdk_window_clear_area (widget->window, area->x, area->y, area->width, area->height);
+ x = widget->allocation.x + border_width;
+ y = widget->allocation.y + border_width;
+ width = widget->allocation.width - border_width * 2;
+ height = widget->allocation.height - border_width * 2;
if (GTK_WIDGET_HAS_DEFAULT (widget) &&
GTK_BUTTON (widget)->relief == GTK_RELIEF_NORMAL)
if (GTK_WIDGET_REALIZED (button) && !button->activate_timeout)
{
- if (gdk_keyboard_grab (widget->window, TRUE,
+ if (gdk_keyboard_grab (button->event_window, TRUE,
gtk_get_current_event_time ()) == 0)
{
gtk_grab_add (widget);
{
GtkBin bin;
+ GdkWindow *event_window;
+
gchar *label_text;
guint activate_timeout;
g_return_if_fail (GTK_IS_CHECK_BUTTON (widget));
g_return_if_fail (allocation != NULL);
+ button = GTK_BUTTON (widget);
check_button = GTK_CHECK_BUTTON (widget);
toggle_button = GTK_TOGGLE_BUTTON (widget);
widget->allocation = *allocation;
if (GTK_WIDGET_REALIZED (widget))
- gdk_window_move_resize (toggle_button->event_window,
+ gdk_window_move_resize (button->event_window,
allocation->x, allocation->y,
allocation->width, allocation->height);
- button = GTK_BUTTON (widget);
-
if (GTK_BIN (button)->child && GTK_WIDGET_VISIBLE (GTK_BIN (button)->child))
{
gint border_width = GTK_CONTAINER (widget)->border_width;
(clist, g_list_nth (clist->row_list,
clist->drag_highlight_row)->data,
clist->drag_highlight_row, clist->drag_highlight_pos);
+
+ if (event->window == clist->title_window)
+ {
+ gint i;
+
+ for (i = 0; i < clist->columns; i++)
+ {
+ if (clist->column[i].button)
+ gtk_container_propagate_expose (GTK_CONTAINER (clist),
+ clist->column[i].button,
+ event);
+ }
+ }
}
return FALSE;
data.container = widget;
data.event = event;
- gtk_container_foreach (GTK_CONTAINER (widget),
- gtk_container_expose_child,
- &data);
+ gtk_container_forall (GTK_CONTAINER (widget),
+ gtk_container_expose_child,
+ &data);
}
return TRUE;
y = 0;
break;
}
+
+ x += widget->allocation.x;
+ y += widget->allocation.y;
state_type = GTK_STATE_NORMAL;
if (!GTK_WIDGET_IS_SENSITIVE (scale))
gpointer callback_data);
/*** GtkNotebook Private Functions ***/
-static void gtk_notebook_panel_realize (GtkNotebook *notebook);
static void gtk_notebook_redraw_tabs (GtkNotebook *notebook);
static void gtk_notebook_redraw_arrows (GtkNotebook *notebook);
static void gtk_notebook_focus_changed (GtkNotebook *notebook,
GdkRectangle *area);
static void gtk_notebook_draw_arrow (GtkNotebook *notebook,
guint arrow);
-static void gtk_notebook_set_shape (GtkNotebook *notebook);
/*** GtkNotebook Size Allocate Functions ***/
static void gtk_notebook_pages_allocate (GtkNotebook *notebook);
gtk_notebook_init (GtkNotebook *notebook)
{
GTK_WIDGET_SET_FLAGS (notebook, GTK_CAN_FOCUS | GTK_RECEIVES_DEFAULT);
- GTK_WIDGET_UNSET_FLAGS (notebook, GTK_NO_WINDOW);
+ GTK_WIDGET_SET_FLAGS (notebook, GTK_NO_WINDOW);
notebook->cur_page = NULL;
notebook->children = NULL;
notebook->first_tab = NULL;
notebook->focus_tab = NULL;
- notebook->panel = NULL;
+ notebook->event_window = NULL;
notebook->menu = NULL;
notebook->tab_hborder = 2;
* gtk_notebook_draw_focus
* gtk_notebook_style_set
*/
+static gboolean
+gtk_notebook_get_event_window_position (GtkNotebook *notebook,
+ GdkRectangle *rectangle)
+{
+ GtkWidget *widget = GTK_WIDGET (notebook);
+
+ if (notebook->show_tabs && notebook->children)
+ {
+ if (rectangle)
+ {
+ GtkNotebookPage *page = notebook->children->data;
+
+ rectangle->x = widget->allocation.x;
+ rectangle->y = widget->allocation.y;
+
+ switch (notebook->tab_pos)
+ {
+ case GTK_POS_TOP:
+ case GTK_POS_BOTTOM:
+ rectangle->width = widget->allocation.width;
+ rectangle->height = page->requisition.height;
+ if (notebook->tab_pos == GTK_POS_BOTTOM)
+ rectangle->y += widget->allocation.height - rectangle->height;
+ break;
+ case GTK_POS_LEFT:
+ case GTK_POS_RIGHT:
+ rectangle->width = page->requisition.width;
+ rectangle->height = widget->allocation.height;
+ if (notebook->tab_pos == GTK_POS_RIGHT)
+ rectangle->x += widget->allocation.width - rectangle->width;
+ break;
+ }
+ }
+
+ return TRUE;
+ }
+ else
+ {
+ if (rectangle)
+ {
+ rectangle->x = rectangle->y = 0;
+ rectangle->width = rectangle->height = 10;
+ }
+ }
+
+ return FALSE;
+}
+
static void
gtk_notebook_map (GtkWidget *widget)
{
}
}
- if (notebook->scrollable)
- gdk_window_show (notebook->panel);
-
- gdk_window_show (widget->window);
+ if (gtk_notebook_get_event_window_position (notebook, NULL))
+ gdk_window_show (notebook->event_window);
}
static void
g_return_if_fail (GTK_IS_NOTEBOOK (widget));
GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
- gdk_window_hide (widget->window);
- if (GTK_NOTEBOOK (widget)->panel)
- gdk_window_hide (GTK_NOTEBOOK (widget)->panel);
+
+ gdk_window_hide (GTK_NOTEBOOK (widget)->event_window);
}
static void
GtkNotebook *notebook;
GdkWindowAttr attributes;
gint attributes_mask;
+ GdkRectangle event_window_pos;
g_return_if_fail (GTK_IS_NOTEBOOK (widget));
notebook = GTK_NOTEBOOK (widget);
GTK_WIDGET_SET_FLAGS (notebook, GTK_REALIZED);
+ gtk_notebook_get_event_window_position (notebook, &event_window_pos);
+
+ widget->window = gtk_widget_get_parent_window (widget);
+ gdk_window_ref (widget->window);
+
attributes.window_type = GDK_WINDOW_CHILD;
- attributes.x = widget->allocation.x;
- attributes.y = widget->allocation.y;
- attributes.width = widget->allocation.width;
- attributes.height = widget->allocation.height;
- attributes.wclass = GDK_INPUT_OUTPUT;
- attributes.visual = gtk_widget_get_visual (widget);
- attributes.colormap = gtk_widget_get_colormap (widget);
+ attributes.x = event_window_pos.x;
+ attributes.y = event_window_pos.y;
+ attributes.width = event_window_pos.width;
+ attributes.height = event_window_pos.height;
+ attributes.wclass = GDK_INPUT_ONLY;
attributes.event_mask = gtk_widget_get_events (widget);
attributes.event_mask |= (GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK);
- attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+ attributes_mask = GDK_WA_X | GDK_WA_Y;
- widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
- gdk_window_set_user_data (widget->window, notebook);
+ notebook->event_window = gdk_window_new (gtk_widget_get_parent_window (widget),
+ &attributes, attributes_mask);
+ gdk_window_set_user_data (notebook->event_window, notebook);
widget->style = gtk_style_attach (widget->style, widget->window);
- gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
-
- gdk_window_set_back_pixmap (widget->window, NULL, TRUE);
- if (notebook->scrollable)
- gtk_notebook_panel_realize (notebook);
}
static void
notebook = GTK_NOTEBOOK (widget);
- if (notebook->panel)
- {
- gdk_window_set_user_data (notebook->panel, NULL);
- gdk_window_destroy (notebook->panel);
- notebook->panel = NULL;
- }
+ gdk_window_set_user_data (notebook->event_window, NULL);
+ gdk_window_destroy (notebook->event_window);
+ notebook->event_window = NULL;
if (GTK_WIDGET_CLASS (parent_class)->unrealize)
(* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
g_return_if_fail (GTK_IS_NOTEBOOK (widget));
g_return_if_fail (allocation != NULL);
+ notebook = GTK_NOTEBOOK (widget);
+
widget->allocation = *allocation;
if (GTK_WIDGET_REALIZED (widget))
- gdk_window_move_resize (widget->window,
- allocation->x, allocation->y,
- allocation->width, allocation->height);
+ {
+ GdkRectangle position;
+
+ if (gtk_notebook_get_event_window_position (notebook, &position))
+ gdk_window_move_resize (notebook->event_window,
+ position.x, position.y,
+ position.width, position.height);
+ }
- notebook = GTK_NOTEBOOK (widget);
if (notebook->children)
{
child_allocation.x = GTK_CONTAINER (widget)->border_width;
child_allocation.y = GTK_CONTAINER (widget)->border_width;
- child_allocation.width = MAX (1, (gint)allocation->width - child_allocation.x * 2);
- child_allocation.height = MAX (1, (gint)allocation->height - child_allocation.y * 2);
+ child_allocation.width = MAX (1, allocation->width - child_allocation.x * 2);
+ child_allocation.height = MAX (1, allocation->height - child_allocation.y * 2);
if (notebook->show_tabs || notebook->show_border)
{
child_allocation.x += widget->style->xthickness;
child_allocation.y += widget->style->ythickness;
- child_allocation.width = MAX (1, (gint)child_allocation.width -
- (gint) widget->style->xthickness * 2);
- child_allocation.height = MAX (1, (gint)child_allocation.height -
- (gint) widget->style->ythickness * 2);
+ child_allocation.width = MAX (1, child_allocation.width -
+ widget->style->xthickness * 2);
+ child_allocation.height = MAX (1, child_allocation.height -
+ widget->style->ythickness * 2);
if (notebook->show_tabs && notebook->children && notebook->cur_page)
{
child_allocation.y += notebook->cur_page->requisition.height;
case GTK_POS_BOTTOM:
child_allocation.height =
- MAX (1, (gint)child_allocation.height -
- (gint)notebook->cur_page->requisition.height);
+ MAX (1, child_allocation.height -
+ notebook->cur_page->requisition.height);
break;
case GTK_POS_LEFT:
child_allocation.x += notebook->cur_page->requisition.width;
case GTK_POS_RIGHT:
child_allocation.width =
- MAX (1, (gint)child_allocation.width -
- (gint)notebook->cur_page->requisition.width);
+ MAX (1, child_allocation.width -
+ notebook->cur_page->requisition.width);
break;
}
}
gtk_notebook_pages_allocate (notebook);
}
- gtk_notebook_set_shape (notebook);
}
static gint
return FALSE;
}
+static gboolean
+gtk_notebook_show_arrows (GtkNotebook *notebook)
+{
+ gboolean show_arrow = FALSE;
+ GList *children;
+
+ if (!notebook->scrollable)
+ return FALSE;
+
+ children = notebook->children;
+ while (children)
+ {
+ GtkNotebookPage *page = children->data;
+
+ if (page->tab_label && !gtk_widget_get_child_visible (page->tab_label))
+ show_arrow = TRUE;
+
+ children = children->next;
+ }
+
+ return show_arrow;
+}
+
+static void
+gtk_notebook_get_arrow_rect (GtkNotebook *notebook,
+ GdkRectangle *rectangle)
+{
+ GdkRectangle event_window_pos;
+
+ if (gtk_notebook_get_event_window_position (notebook, &event_window_pos))
+ {
+ rectangle->width = 2 * ARROW_SIZE + ARROW_SPACING;
+ rectangle->height = ARROW_SIZE;
+
+ switch (notebook->tab_pos)
+ {
+ case GTK_POS_LEFT:
+ rectangle->x = event_window_pos.x + (event_window_pos.width - rectangle->width) / 2;
+ break;
+ case GTK_POS_RIGHT:
+ rectangle->x = event_window_pos.x + event_window_pos.width - (event_window_pos.width - rectangle->width) / 2;
+ break;
+ case GTK_POS_TOP:
+ case GTK_POS_BOTTOM:
+ rectangle->x = event_window_pos.x + event_window_pos.width - rectangle->width;
+ break;
+ }
+
+ switch (notebook->tab_pos)
+ {
+ case GTK_POS_LEFT:
+ case GTK_POS_RIGHT:
+ rectangle->y = event_window_pos.y + event_window_pos.height - rectangle->height;
+ break;
+ case GTK_POS_TOP:
+ rectangle->y = event_window_pos.y + (event_window_pos.height - rectangle->height) / 2;
+ break;
+ case GTK_POS_BOTTOM:
+ rectangle->y = event_window_pos.y + event_window_pos.height - (event_window_pos.height - rectangle->height) / 2;
+ break;
+ }
+ }
+}
+
+static GtkArrowType
+gtk_notebook_get_arrow (GtkNotebook *notebook,
+ gint x,
+ gint y)
+{
+ GdkRectangle arrow_rect;
+ GdkRectangle event_window_pos;
+
+ if (gtk_notebook_show_arrows (notebook))
+ {
+ gtk_notebook_get_event_window_position (notebook, &event_window_pos);
+ gtk_notebook_get_arrow_rect (notebook, &arrow_rect);
+
+ x -= arrow_rect.x - event_window_pos.x;
+ y -= arrow_rect.y - event_window_pos.y;
+
+ if (y >= 0 && y < arrow_rect.height)
+ {
+ if (x >= 0 && x < ARROW_SIZE + ARROW_SPACING / 2)
+ return GTK_ARROW_LEFT;
+ else if (x >= ARROW_SIZE + ARROW_SPACING / 2 && x < arrow_rect.width)
+ return GTK_ARROW_RIGHT;
+ }
+ }
+
+ return 0;
+}
+
static gboolean
gtk_notebook_arrow_button_press (GtkNotebook *notebook,
+ GtkArrowType arrow,
GdkEventButton *event)
{
GtkWidget *widget = GTK_WIDGET (notebook);
- GtkArrowType arrow = event->x <= ARROW_SIZE + ARROW_SPACING / 2 ? GTK_ARROW_LEFT : GTK_ARROW_RIGHT;
-
if (!GTK_WIDGET_HAS_FOCUS (widget))
gtk_widget_grab_focus (widget);
gtk_notebook_button_press (GtkWidget *widget,
GdkEventButton *event)
{
- GtkNotebook *notebook;
+ GtkNotebook *notebook = GTK_NOTEBOOK (widget);
GtkNotebookPage *page;
GList *children;
+ GtkArrowType arrow;
+ GdkRectangle event_window_pos;
gint num;
-
- g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
-
- notebook = GTK_NOTEBOOK (widget);
+ gint x, y;
if (event->type != GDK_BUTTON_PRESS || !notebook->children ||
notebook->button)
return FALSE;
- if (event->window == notebook->panel)
+ arrow = gtk_notebook_get_arrow (notebook, event->x, event->y);
+ if (arrow)
+ return gtk_notebook_arrow_button_press (notebook, arrow, event);
+
+ if (event->button == 3 && notebook->menu)
{
- return gtk_notebook_arrow_button_press (notebook, event);
+ gtk_menu_popup (GTK_MENU (notebook->menu), NULL, NULL,
+ NULL, NULL, 3, event->time);
+ return TRUE;
}
- else if (event->window == widget->window)
- {
- if (event->button == 3 && notebook->menu)
- {
- gtk_menu_popup (GTK_MENU (notebook->menu), NULL, NULL,
- NULL, NULL, 3, event->time);
- return TRUE;
- }
- num = 0;
- children = notebook->children;
- while (children)
+ /* Translate coordinates from event_window to widget->window
+ */
+ gtk_notebook_get_event_window_position (notebook, &event_window_pos);
+ x = event->x + event_window_pos.x;
+ y = event->y + event_window_pos.y;
+
+ num = 0;
+ children = notebook->children;
+ while (children)
+ {
+ page = children->data;
+
+ if (GTK_WIDGET_VISIBLE (page->child) &&
+ page->tab_label && GTK_WIDGET_MAPPED (page->tab_label) &&
+ (x >= page->allocation.x) &&
+ (y >= page->allocation.y) &&
+ (x <= (page->allocation.x + page->allocation.width)) &&
+ (y <= (page->allocation.y + page->allocation.height)))
{
- page = children->data;
-
- if (GTK_WIDGET_VISIBLE (page->child) &&
- page->tab_label && GTK_WIDGET_MAPPED (page->tab_label) &&
- (event->x >= page->allocation.x) &&
- (event->y >= page->allocation.y) &&
- (event->x <= (page->allocation.x + page->allocation.width)) &&
- (event->y <= (page->allocation.y + page->allocation.height)))
+ if (page == notebook->cur_page && notebook->focus_tab &&
+ notebook->focus_tab != children &&
+ GTK_WIDGET_HAS_FOCUS (notebook))
{
- if (page == notebook->cur_page && notebook->focus_tab &&
- notebook->focus_tab != children &&
- GTK_WIDGET_HAS_FOCUS (notebook))
- {
- GtkNotebookPage *old_page;
-
- notebook->child_has_focus = FALSE;
- old_page = (GtkNotebookPage *)
- (notebook->focus_tab->data);
- gtk_notebook_switch_focus_tab (notebook, children);
- gtk_notebook_focus_changed (notebook, old_page);
- }
- else
- {
- gtk_notebook_switch_focus_tab (notebook, children);
- gtk_widget_grab_focus (widget);
- gtk_notebook_switch_page (notebook, page, num);
- }
- break;
+ GtkNotebookPage *old_page;
+
+ notebook->child_has_focus = FALSE;
+ old_page = (GtkNotebookPage *)
+ (notebook->focus_tab->data);
+ gtk_notebook_switch_focus_tab (notebook, children);
+ gtk_notebook_focus_changed (notebook, old_page);
}
- children = children->next;
- num++;
+ else
+ {
+ gtk_notebook_switch_focus_tab (notebook, children);
+ gtk_widget_grab_focus (widget);
+ gtk_notebook_switch_page (notebook, page, num);
+ }
+ break;
}
- if (!children && !GTK_WIDGET_HAS_FOCUS (widget))
- gtk_widget_grab_focus (widget);
- return TRUE;
+ children = children->next;
+ num++;
}
-
- return FALSE;
+ if (!children && !GTK_WIDGET_HAS_FOCUS (widget))
+ gtk_widget_grab_focus (widget);
+
+ return TRUE;
}
static gint
GdkEventCrossing *event)
{
GtkNotebook *notebook;
+ GtkArrowType arrow;
g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
notebook = GTK_NOTEBOOK (widget);
- if (event->window == notebook->panel)
- {
- gint x;
- gint y;
-
- gdk_window_get_pointer (notebook->panel, &x, &y, NULL);
-
- if (x <= ARROW_SIZE + ARROW_SPACING / 2)
- notebook->in_child = GTK_ARROW_LEFT;
- else
- notebook->in_child = GTK_ARROW_RIGHT;
+ arrow = gtk_notebook_get_arrow (notebook, event->x, event->y);
+ if (arrow != notebook->in_child)
+ {
+ notebook->in_child = arrow;
gtk_notebook_redraw_arrows (notebook);
+
+ return TRUE;
}
- return FALSE;
+ return TRUE;
}
static gint
gtk_notebook_leave_notify (GtkWidget *widget,
GdkEventCrossing *event)
{
- GtkNotebook *notebook;
+ GtkNotebook *notebook = GTK_NOTEBOOK (widget);
+ GtkArrowType arrow;
- g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
-
- notebook = GTK_NOTEBOOK (widget);
+ arrow = gtk_notebook_get_arrow (notebook, event->x, event->y);
- if (event->window == notebook->panel)
- gtk_notebook_redraw_arrows (notebook);
+ if (notebook->in_child)
+ {
+ notebook->in_child = 0;
+ gtk_notebook_redraw_arrows (notebook);
+ }
- return FALSE;
+ return TRUE;
}
static gint
gtk_notebook_motion_notify (GtkWidget *widget,
GdkEventMotion *event)
{
- GtkNotebook *notebook;
+ GtkNotebook *notebook = GTK_NOTEBOOK (widget);
+ GtkArrowType arrow;
- g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
-
- notebook = GTK_NOTEBOOK (widget);
-
if (notebook->button)
return FALSE;
- if (event->window == notebook->panel)
- {
- gint x;
- GtkArrowType old_child = notebook->in_child;
-
- x = event->x;
- if (event->is_hint)
- gdk_window_get_pointer (notebook->panel, &x, NULL, NULL);
-
- if (x <= ARROW_SIZE + ARROW_SPACING / 2)
- notebook->in_child = GTK_ARROW_LEFT;
- else
- notebook->in_child = GTK_ARROW_RIGHT;
+ arrow = gtk_notebook_get_arrow (notebook, event->x, event->y);
- if (old_child != notebook->in_child)
- gtk_notebook_redraw_arrows (notebook);
+ if (arrow != notebook->in_child)
+ {
+ notebook->in_child = arrow;
+ gtk_notebook_redraw_arrows (notebook);
}
- return FALSE;
+ return TRUE;
}
static gint
gtk_notebook_focus_in (GtkWidget *widget,
GdkEventFocus *event)
{
- g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
-
GTK_NOTEBOOK (widget)->child_has_focus = FALSE;
return (* GTK_WIDGET_CLASS (parent_class)->focus_in_event) (widget, event);
static void
gtk_notebook_draw_focus (GtkWidget *widget)
{
- GtkNotebook *notebook;
-
- g_return_if_fail (GTK_IS_NOTEBOOK (widget));
-
- notebook = GTK_NOTEBOOK (widget);
+ GtkNotebook *notebook = GTK_NOTEBOOK (widget);
if (GTK_WIDGET_DRAWABLE (widget) && notebook->show_tabs &&
notebook->focus_tab)
/* Private GtkNotebook Functions:
*
- * gtk_notebook_panel_realize
* gtk_notebook_redraw_tabs
* gtk_notebook_focus_changed
* gtk_notebook_real_remove
* gtk_notebook_real_page_position
* gtk_notebook_search_page
*/
-static void
-gtk_notebook_panel_realize (GtkNotebook *notebook)
-{
- GtkWidget *widget;
- GdkWindowAttr attributes;
- gint attributes_mask;
-
- g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
-
- widget = GTK_WIDGET (notebook);
-
- attributes.window_type = GDK_WINDOW_CHILD;
- attributes.wclass = GDK_INPUT_OUTPUT;
- attributes.visual = gtk_widget_get_visual (widget);
- attributes.colormap = gtk_widget_get_colormap (widget);
- attributes.event_mask = gtk_widget_get_events (widget);
- attributes.event_mask |= GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK
- | GDK_BUTTON_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_ENTER_NOTIFY_MASK
- | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK;
-
- attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
-
- attributes.width = 2 * ARROW_SIZE + ARROW_SPACING;
- attributes.height = ARROW_SIZE;
-
- attributes.x = (widget->allocation.width - attributes.width -
- GTK_CONTAINER (notebook)->border_width);
- attributes.y = (widget->allocation.height - ARROW_SIZE -
- GTK_CONTAINER (notebook)->border_width);
- if (notebook->tab_pos == GTK_POS_TOP)
- attributes.y = GTK_CONTAINER (notebook)->border_width;
- else if (notebook->tab_pos == GTK_POS_LEFT)
- attributes.x = (widget->allocation.x +
- GTK_CONTAINER (notebook)->border_width);
-
- notebook->panel = gdk_window_new (widget->window, &attributes,
- attributes_mask);
- gtk_style_set_background (widget->style, notebook->panel,
- GTK_STATE_NORMAL);
- gdk_window_set_back_pixmap (widget->window, NULL, TRUE);
- gdk_window_set_user_data (notebook->panel, widget);
-}
-
static void
gtk_notebook_redraw_tabs (GtkNotebook *notebook)
{
static void
gtk_notebook_redraw_arrows (GtkNotebook *notebook)
{
- if (GTK_WIDGET_MAPPED (notebook) && notebook->panel)
- gdk_window_invalidate_rect (notebook->panel, NULL, FALSE);
+ if (GTK_WIDGET_MAPPED (notebook) && gtk_notebook_show_arrows (notebook))
+ {
+ GdkRectangle rect;
+
+ gtk_notebook_get_arrow_rect (notebook, &rect);
+ gdk_window_invalidate_rect (GTK_WIDGET (notebook)->window, &rect, FALSE);
+ }
}
static void
g_list_free (list);
g_free (page);
+ if (!notebook->children && notebook->show_tabs &&
+ GTK_WIDGET_MAPPED (notebook))
+ gdk_window_hide (notebook->event_window);
+
gtk_notebook_update_labels (notebook);
if (need_resize)
gtk_widget_queue_resize (GTK_WIDGET (notebook));
* gtk_notebook_paint
* gtk_notebook_draw_tab
* gtk_notebook_draw_arrow
- * gtk_notebook_set_shape
*/
static void
gtk_notebook_paint (GtkWidget *widget,
gboolean showarrow;
gint width, height;
gint x, y;
+ gint border_width = GTK_CONTAINER (widget)->border_width;
gint gap_x = 0, gap_width = 0;
g_return_if_fail (GTK_IS_NOTEBOOK (widget));
if ((!notebook->show_tabs && !notebook->show_border) ||
!notebook->cur_page || !GTK_WIDGET_VISIBLE (notebook->cur_page->child))
- {
- gdk_window_clear_area (widget->window,
- area->x, area->y,
- area->width, area->height);
- return;
- }
+ return;
- x = GTK_CONTAINER (widget)->border_width;
- y = GTK_CONTAINER (widget)->border_width;
+ x = widget->allocation.x + border_width;
+ y = widget->allocation.y + border_width;
width = widget->allocation.width - x * 2;
height = widget->allocation.height - y * 2;
switch (notebook->tab_pos)
{
case GTK_POS_TOP:
- gap_x = (notebook->cur_page->allocation.x -
- GTK_CONTAINER(notebook)->border_width);
+ gap_x = (notebook->cur_page->allocation.x - border_width);
gap_width = notebook->cur_page->allocation.width;
break;
case GTK_POS_BOTTOM:
- gap_x = (notebook->cur_page->allocation.x -
- GTK_CONTAINER(notebook)->border_width);
+ gap_x = (notebook->cur_page->allocation.x - border_width);
gap_width = notebook->cur_page->allocation.width;
break;
case GTK_POS_LEFT:
- gap_x = (notebook->cur_page->allocation.y -
- GTK_CONTAINER(notebook)->border_width);
+ gap_x = (notebook->cur_page->allocation.y - border_width);
gap_width = notebook->cur_page->allocation.height;
break;
case GTK_POS_RIGHT:
- gap_x = (notebook->cur_page->allocation.y -
- GTK_CONTAINER(notebook)->border_width);
+ gap_x = (notebook->cur_page->allocation.y - border_width);
gap_width = notebook->cur_page->allocation.height;
break;
}
GtkStateType state_type;
GtkShadowType shadow_type;
GtkWidget *widget;
+ GdkRectangle arrow_rect;
+
+ gtk_notebook_get_arrow_rect (notebook, &arrow_rect);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
notebook->tab_pos == GTK_POS_RIGHT)
arrow = GTK_ARROW_UP;
- gdk_window_clear_area (notebook->panel, 0, 0, ARROW_SIZE, ARROW_SIZE);
- gtk_paint_arrow (widget->style, notebook->panel, state_type,
+ gtk_paint_arrow (widget->style, widget->window, state_type,
shadow_type, NULL, GTK_WIDGET(notebook), "notebook",
arrow, TRUE,
- 0, 0, ARROW_SIZE, ARROW_SIZE);
+ arrow_rect.x, arrow_rect.y, ARROW_SIZE, ARROW_SIZE);
}
else
{
notebook->tab_pos == GTK_POS_RIGHT)
arrow = GTK_ARROW_DOWN;
- gdk_window_clear_area(notebook->panel, ARROW_SIZE + ARROW_SPACING,
- 0, ARROW_SIZE, ARROW_SIZE);
- gtk_paint_arrow (widget->style, notebook->panel, state_type,
+ gtk_paint_arrow (widget->style, widget->window, state_type,
shadow_type, NULL, GTK_WIDGET(notebook), "notebook",
- arrow, TRUE, ARROW_SIZE + ARROW_SPACING,
- 0, ARROW_SIZE, ARROW_SIZE);
+ arrow, TRUE, arrow_rect.x + ARROW_SIZE + ARROW_SPACING,
+ arrow_rect.y, ARROW_SIZE, ARROW_SIZE);
}
}
}
-static void
-gtk_notebook_set_shape (GtkNotebook *notebook)
-{
- GtkWidget *widget = NULL;
- GdkPixmap *pm = NULL;
- GdkGC *pmgc = NULL;
- GdkColor col;
- gint x, y, width, height, w, h, depth;
- GtkNotebookPage *page;
- GList *children;
-
- if (!GTK_WIDGET(notebook)->window)
- return;
-
- widget = GTK_WIDGET(notebook);
-
- w = widget->allocation.width;
- h = widget->allocation.height;
-
- pm = gdk_pixmap_new (widget->window, w, h, 1);
- pmgc = gdk_gc_new (pm);
-
- /* clear the shape mask */
- col.pixel = 0;
- gdk_gc_set_foreground(pmgc, &col);
- gdk_draw_rectangle(pm, pmgc, TRUE, 0, 0, w, h);
-
- col.pixel = 1;
- gdk_gc_set_foreground(pmgc, &col);
-
- /* draw the shape for the notebook page itself */
- x = GTK_CONTAINER(notebook)->border_width;
- y = GTK_CONTAINER(notebook)->border_width;
- width = widget->allocation.width - x * 2;
- height = widget->allocation.height - y * 2;
-
- if (notebook->show_tabs && notebook->children)
- {
- if (!(notebook->show_tabs))
- {
- page = notebook->first_tab->data;
- switch (notebook->tab_pos)
- {
- case GTK_POS_TOP:
- y += page->allocation.height +
- widget->style->ythickness;
- case GTK_POS_BOTTOM:
- height -= page->allocation.height +
- widget->style->ythickness;
- break;
- case GTK_POS_LEFT:
- x += page->allocation.width +
- widget->style->xthickness;
- case GTK_POS_RIGHT:
- width -= page->allocation.width +
- widget->style->xthickness;
- break;
- }
- }
- else
- {
- if (notebook->cur_page)
- page = notebook->cur_page;
- else
- page = notebook->children->data;
-
- if (!GTK_WIDGET_MAPPED (page->tab_label))
- {
- if (notebook->tab_pos == GTK_POS_LEFT)
- {
- x -= widget->style->xthickness * 2;
- width += widget->style->xthickness * 2;
- }
- else if (notebook->tab_pos == GTK_POS_RIGHT)
- width += widget->style->xthickness * 2;
- }
- switch (notebook->tab_pos)
- {
- case GTK_POS_TOP:
- y += page->allocation.height;
- case GTK_POS_BOTTOM:
- height -= page->allocation.height;
- break;
- case GTK_POS_LEFT:
- x += page->allocation.width;
- case GTK_POS_RIGHT:
- width -= page->allocation.width;
- break;
- }
- }
- }
- gdk_draw_rectangle(pm, pmgc, TRUE, x, y, width, height);
-
- /* if theres an area for scrolling arrows draw the shape for them */
- if (notebook->panel && gdk_window_is_visible (notebook->panel))
- {
- gdk_window_get_geometry(notebook->panel, &x, &y, &width, &height, &depth);
- gdk_draw_rectangle(pm, pmgc, TRUE, x, y, width, height);
- }
-
- /* draw the shapes of all the children */
- if (notebook->show_tabs)
- {
- children = notebook->children;
- while (children)
- {
- page = children->data;
- if (gtk_widget_get_child_visible (page->tab_label))
- {
- x = page->allocation.x;
- y = page->allocation.y;
- width = page->allocation.width;
- height = page->allocation.height;
- gdk_draw_rectangle(pm, pmgc, TRUE, x, y, width, height);
- }
- children = children->next;
- }
- }
-
- /* set the mask */
- gdk_window_shape_combine_mask(widget->window, pm, 0, 0);
- gdk_pixmap_unref(pm);
- gdk_gc_destroy(pmgc);
-}
-
/* Private GtkNotebook Size Allocate Functions:
*
* gtk_notebook_pages_allocate
}
}
- if (GTK_WIDGET_REALIZED (notebook))
- {
- gdk_window_move (notebook->panel, x, y);
- gdk_window_show (notebook->panel);
- }
-
if (tab_space < 0)
{
tab_space = -tab_space;
notebook->first_tab = gtk_notebook_search_page (notebook, NULL,
STEP_NEXT, TRUE);
tab_space = 0;
- if (GTK_WIDGET_REALIZED (notebook))
- gdk_window_hide (notebook->panel);
}
}
}
done:
- gtk_notebook_set_shape (notebook);
gtk_notebook_redraw_tabs (notebook);
}
{
child_allocation.x = (xthickness + FOCUS_WIDTH +
notebook->tab_hborder);
- child_allocation.width = MAX (1, (((gint) page->allocation.width) -
+ child_allocation.width = MAX (1, (page->allocation.width -
2 * child_allocation.x));
child_allocation.x += page->allocation.x;
}
page->allocation.y);
if (notebook->tab_pos == GTK_POS_TOP)
child_allocation.y += ythickness;
- child_allocation.height = MAX (1, (((gint) page->allocation.height) - ythickness -
+ child_allocation.height = MAX (1, (page->allocation.height - ythickness -
2 * (notebook->tab_vborder + FOCUS_WIDTH)));
break;
case GTK_POS_LEFT:
if (page->fill)
{
child_allocation.y = ythickness + padding;
- child_allocation.height = MAX (1, (((gint) page->allocation.height) -
+ child_allocation.height = MAX (1, (page->allocation.height -
2 * child_allocation.y));
child_allocation.y += page->allocation.y;
}
child_allocation.x = page->allocation.x + notebook->tab_hborder + FOCUS_WIDTH;
if (notebook->tab_pos == GTK_POS_LEFT)
child_allocation.x += xthickness;
- child_allocation.width = MAX (1, (((gint) page->allocation.width) - xthickness -
+ child_allocation.width = MAX (1, (page->allocation.width - xthickness -
2 * (notebook->tab_hborder + FOCUS_WIDTH)));
break;
}
old_child = notebook->focus_tab;
notebook->focus_tab = new_child;
- if (notebook->scrollable && GTK_WIDGET_DRAWABLE (notebook))
+ if (notebook->scrollable)
gtk_notebook_redraw_arrows (notebook);
if (!notebook->show_tabs || !notebook->focus_tab)
gtk_notebook_focus_changed (notebook, old_page);
else
gtk_notebook_pages_allocate (notebook);
-
- gtk_notebook_set_shape (notebook);
}
static void
(GtkSignalFunc) gtk_notebook_mnemonic_activate_switch_page,
notebook);
+ if (notebook->show_tabs && GTK_WIDGET_MAPPED (notebook))
+ gdk_window_show (notebook->event_window);
+
gtk_widget_child_notify (child, "tab_expand");
gtk_widget_child_notify (child, "tab_fill");
gtk_widget_child_notify (child, "tab_pack");
else
gtk_widget_hide (page->tab_label);
}
-
- if (notebook->panel)
- gdk_window_hide (notebook->panel);
}
else
{
{
notebook->scrollable = scrollable;
- if (GTK_WIDGET_REALIZED (notebook))
- {
- if (scrollable)
- {
- gtk_notebook_panel_realize (notebook);
- }
- else if (notebook->panel)
- {
- gdk_window_set_user_data (notebook->panel, NULL);
- gdk_window_destroy (notebook->panel);
- notebook->panel = NULL;
- }
- }
-
if (GTK_WIDGET_VISIBLE (notebook))
gtk_widget_queue_resize (GTK_WIDGET (notebook));
GList *focus_tab;
GtkWidget *menu;
- GdkWindow *panel;
+ GdkWindow *event_window;
guint32 timer;
GtkAllocation *allocation)
{
GtkWidget *child;
+ GtkButton *button = GTK_BUTTON (widget);
GtkAllocation child_allocation;
GtkOptionMenuProps props;
gint border_width;
widget->allocation = *allocation;
if (GTK_WIDGET_REALIZED (widget))
- gdk_window_move_resize (widget->window,
+ gdk_window_move_resize (button->event_window,
allocation->x + border_width, allocation->y + border_width,
allocation->width - border_width * 2, allocation->height - border_width * 2);
child = GTK_BIN (widget)->child;
if (child && GTK_WIDGET_VISIBLE (child))
{
- child_allocation.x = GTK_WIDGET (widget)->style->xthickness + 1;
- child_allocation.y = GTK_CONTAINER (widget)->border_width + 1;
- child_allocation.width = MAX (1, (gint)allocation->width - child_allocation.x * 2 - border_width * 2 -
+ gint xthickness = GTK_WIDGET (widget)->style->xthickness;
+
+ child_allocation.x = widget->allocation.x + border_width + xthickness + 1;
+ child_allocation.y = widget->allocation.y + 2 * border_width + 1;
+ child_allocation.width = MAX (1, (gint)allocation->width - (xthickness + 1) * 2 - border_width * 2 -
props.indicator_size.width - props.indicator_spacing.left - props.indicator_spacing.right -
CHILD_LEFT_SPACING - CHILD_RIGHT_SPACING - 2);
- child_allocation.height = MAX (1, (gint)allocation->height - child_allocation.y * 2 - border_width * 2 -
+ child_allocation.height = MAX (1, (gint)allocation->height - (border_width + 1) * 2 - border_width * 2 -
CHILD_TOP_SPACING - CHILD_BOTTOM_SPACING - 2);
child_allocation.x += CHILD_LEFT_SPACING;
child_allocation.y += CHILD_TOP_SPACING;
border_width = GTK_CONTAINER (widget)->border_width;
gtk_option_menu_get_props (GTK_OPTION_MENU (widget), &props);
- button_area.x = 0;
- button_area.y = 0;
+ button_area.x = widget->allocation.x + border_width;
+ button_area.y = widget->allocation.y + border_width;
button_area.width = widget->allocation.width - 2 * border_width;
button_area.height = widget->allocation.height - 2 * border_width;
button_area.y += 1;
button_area.width -= 2;
button_area.height -= 2;
-
- /* This is evil, and should be elimated here and in the button
- * code. The point is to clear the focus, and make it
- * sort of transparent if it isn't there.
- */
- gdk_window_set_back_pixmap (widget->window, NULL, TRUE);
- gdk_window_clear_area (widget->window, area->x, area->y, area->width, area->height);
}
gtk_paint_box (widget->style, widget->window,
GtkOptionMenu *option_menu;
GtkWidget *active;
GtkWidget *child;
+ GtkWidget *widget;
GtkRequisition requisition;
GList *children;
gint screen_width;
g_return_if_fail (GTK_IS_OPTION_MENU (user_data));
option_menu = GTK_OPTION_MENU (user_data);
+ widget = GTK_WIDGET (option_menu);
gtk_widget_get_child_requisition (GTK_WIDGET (menu), &requisition);
menu_width = requisition.width;
active = gtk_menu_get_active (GTK_MENU (option_menu->menu));
- gdk_window_get_origin (GTK_WIDGET (option_menu)->window, &menu_xpos, &menu_ypos);
+ gdk_window_get_origin (widget->window, &menu_xpos, &menu_ypos);
- menu_ypos += GTK_WIDGET (option_menu)->allocation.height / 2 - 2;
+ menu_xpos += widget->allocation.x;
+ menu_ypos += widget->allocation.y + widget->allocation.height / 2 - 2;
if (active != NULL)
{
GtkAllocation *allocation);
static void gtk_range_realize (GtkWidget *widget);
static void gtk_range_unrealize (GtkWidget *widget);
+static void gtk_range_map (GtkWidget *widget);
+static void gtk_range_unmap (GtkWidget *widget);
static gint gtk_range_expose (GtkWidget *widget,
GdkEventExpose *event);
static gint gtk_range_button_press (GtkWidget *widget,
widget_class->size_allocate = gtk_range_size_allocate;
widget_class->realize = gtk_range_realize;
widget_class->unrealize = gtk_range_unrealize;
+ widget_class->map = gtk_range_map;
+ widget_class->unmap = gtk_range_unmap;
widget_class->expose_event = gtk_range_expose;
widget_class->button_press_event = gtk_range_button_press;
widget_class->button_release_event = gtk_range_button_release;
static void
gtk_range_init (GtkRange *range)
{
+ GTK_WIDGET_SET_FLAGS (range, GTK_NO_WINDOW);
+
range->adjustment = NULL;
range->update_policy = GTK_UPDATE_CONTINUOUS;
range->inverted = FALSE;
range = GTK_RANGE (widget);
+ widget->allocation = *allocation;
+
range->need_recalc = TRUE;
gtk_range_calc_layout (range, range->adjustment->value);
- (* GTK_WIDGET_CLASS (parent_class)->size_allocate) (widget, allocation);
+ if (GTK_WIDGET_REALIZED (range))
+ gdk_window_move_resize (range->event_window,
+ widget->allocation.x,
+ widget->allocation.y,
+ widget->allocation.width,
+ widget->allocation.height);
}
static void
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
+ widget->window = gtk_widget_get_parent_window (widget);
+ gdk_window_ref (widget->window);
+
attributes.window_type = GDK_WINDOW_CHILD;
attributes.x = widget->allocation.x;
attributes.y = widget->allocation.y;
attributes.width = widget->allocation.width;
attributes.height = widget->allocation.height;
- attributes.wclass = GDK_INPUT_OUTPUT;
- attributes.visual = gtk_widget_get_visual (widget);
- attributes.colormap = gtk_widget_get_colormap (widget);
+ attributes.wclass = GDK_INPUT_ONLY;
attributes.event_mask = gtk_widget_get_events (widget);
attributes.event_mask |= (GDK_EXPOSURE_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK);
- attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+ attributes_mask = GDK_WA_X | GDK_WA_Y;
- widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
- gdk_window_set_user_data (widget->window, range);
+ range->event_window = gdk_window_new (gtk_widget_get_parent_window (widget),
+ &attributes, attributes_mask);
+ gdk_window_set_user_data (range->event_window, range);
widget->style = gtk_style_attach (widget->style, widget->window);
- gtk_style_set_background (widget->style, widget->window, widget->state);
}
static void
gtk_range_remove_step_timer (range);
gtk_range_remove_update_timer (range);
+ gdk_window_set_user_data (range->event_window, NULL);
+ gdk_window_destroy (range->event_window);
+ range->event_window = NULL;
+
if (GTK_WIDGET_CLASS (parent_class)->unrealize)
(* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
}
+static void
+gtk_range_map (GtkWidget *widget)
+{
+ GtkRange *range = GTK_RANGE (widget);
+
+ g_return_if_fail (GTK_IS_RANGE (widget));
+
+ gdk_window_show (range->event_window);
+
+ GTK_WIDGET_CLASS (parent_class)->map (widget);
+}
+
+static void
+gtk_range_unmap (GtkWidget *widget)
+{
+ GtkRange *range = GTK_RANGE (widget);
+
+ g_return_if_fail (GTK_IS_RANGE (widget));
+
+ gdk_window_hide (range->event_window);
+
+ GTK_WIDGET_CLASS (parent_class)->unmap (widget);
+}
+
static void
draw_stepper (GtkRange *range,
GdkRectangle *rect,
GtkStateType state_type;
GtkShadowType shadow_type;
GdkRectangle intersection;
+ GtkWidget *widget = GTK_WIDGET (range);
/* More to get the right clip region than for efficiency */
if (!gdk_rectangle_intersect (area, rect, &intersection))
return;
+
+ intersection.x += widget->allocation.x;
+ intersection.y += widget->allocation.y;
if (!GTK_WIDGET_IS_SENSITIVE (range))
state_type = GTK_STATE_INSENSITIVE;
&intersection, GTK_WIDGET (range),
GTK_RANGE_GET_CLASS (range)->stepper_detail,
arrow_type,
- TRUE, rect->x, rect->y, rect->width, rect->height);
+ TRUE,
+ widget->allocation.x + rect->x,
+ widget->allocation.y + rect->y,
+ rect->width, rect->height);
}
static gint
GtkRange *range;
gboolean sensitive;
GtkStateType state;
+ GdkRectangle expose_area; /* Relative to widget->allocation */
GdkRectangle area;
g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
range = GTK_RANGE (widget);
+ expose_area = event->area;
+ expose_area.x -= widget->allocation.x;
+ expose_area.y -= widget->allocation.y;
+
gtk_range_calc_layout (range, range->adjustment->value);
sensitive = GTK_WIDGET_IS_SENSITIVE (widget);
-
+
/* Just to be confusing, we draw the trough for the whole
* range rectangle, not the trough rectangle (the trough
* rectangle is just for hit detection)
/* The gdk_rectangle_intersect is more to get the right
* clip region (limited to range_rect) than for efficiency
*/
- if (gdk_rectangle_intersect (&event->area, &range->range_rect,
+ if (gdk_rectangle_intersect (&expose_area, &range->range_rect,
&area))
{
+ area.x += widget->allocation.x;
+ area.y += widget->allocation.y;
+
gtk_paint_box (widget->style,
widget->window,
sensitive ? GTK_STATE_ACTIVE : GTK_STATE_INSENSITIVE,
GTK_SHADOW_IN,
&area, GTK_WIDGET(range), "trough",
- range->range_rect.x,
- range->range_rect.y,
+ widget->allocation.x + range->range_rect.x,
+ widget->allocation.y + range->range_rect.y,
range->range_rect.width,
range->range_rect.height);
gtk_paint_focus (widget->style,
widget->window,
&area, widget, "trough",
- range->range_rect.x,
- range->range_rect.y,
+ widget->allocation.x + range->range_rect.x,
+ widget->allocation.y + range->range_rect.y,
range->range_rect.width,
range->range_rect.height);
}
else
state = GTK_STATE_NORMAL;
- if (gdk_rectangle_intersect (&event->area,
+ if (gdk_rectangle_intersect (&expose_area,
&range->layout->slider,
&area))
{
+ area.x += widget->allocation.x;
+ area.y += widget->allocation.y;
+
gtk_paint_slider (widget->style,
widget->window,
state,
GTK_SHADOW_OUT,
- &event->area,
+ &area,
widget,
GTK_RANGE_GET_CLASS (range)->slider_detail,
- range->layout->slider.x,
- range->layout->slider.y,
+ widget->allocation.x + range->layout->slider.x,
+ widget->allocation.y + range->layout->slider.y,
range->layout->slider.width,
range->layout->slider.height,
range->orientation);
range->orientation == GTK_ORIENTATION_VERTICAL ? GTK_ARROW_UP : GTK_ARROW_LEFT,
range->layout->grab_location == MOUSE_STEPPER_A,
range->layout->mouse_location == MOUSE_STEPPER_A,
- &event->area);
+ &expose_area);
if (range->has_stepper_b)
draw_stepper (range, &range->layout->stepper_b,
range->orientation == GTK_ORIENTATION_VERTICAL ? GTK_ARROW_DOWN : GTK_ARROW_RIGHT,
range->layout->grab_location == MOUSE_STEPPER_B,
range->layout->mouse_location == MOUSE_STEPPER_B,
- &event->area);
+ &expose_area);
if (range->has_stepper_c)
draw_stepper (range, &range->layout->stepper_c,
range->orientation == GTK_ORIENTATION_VERTICAL ? GTK_ARROW_UP : GTK_ARROW_LEFT,
range->layout->grab_location == MOUSE_STEPPER_C,
range->layout->mouse_location == MOUSE_STEPPER_C,
- &event->area);
+ &expose_area);
if (range->has_stepper_d)
draw_stepper (range, &range->layout->stepper_d,
range->orientation == GTK_ORIENTATION_VERTICAL ? GTK_ARROW_DOWN : GTK_ARROW_RIGHT,
range->layout->grab_location == MOUSE_STEPPER_D,
range->layout->mouse_location == MOUSE_STEPPER_D,
- &event->area);
+ &expose_area);
return FALSE;
}
range = GTK_RANGE (widget);
- gdk_window_get_pointer (widget->window, &x, &y, NULL);
+ gdk_window_get_pointer (range->event_window, &x, &y, NULL);
range->layout->mouse_x = x;
range->layout->mouse_y = y;
gint slide_initial_slider_position;
gint slide_initial_coordinate;
guint update_timeout_id;
+ GdkWindow *event_window;
};
struct _GtkRangeClass
static void gtk_toggle_button_init (GtkToggleButton *toggle_button);
static void gtk_toggle_button_paint (GtkWidget *widget,
GdkRectangle *area);
-static void gtk_toggle_button_size_allocate (GtkWidget *widget,
- GtkAllocation *allocation);
static gint gtk_toggle_button_expose (GtkWidget *widget,
GdkEventExpose *event);
static void gtk_toggle_button_pressed (GtkButton *button);
guint prop_id,
GValue *value,
GParamSpec *pspec);
-static void gtk_toggle_button_realize (GtkWidget *widget);
-static void gtk_toggle_button_unrealize (GtkWidget *widget);
-static void gtk_toggle_button_map (GtkWidget *widget);
-static void gtk_toggle_button_unmap (GtkWidget *widget);
static void gtk_toggle_button_update_state (GtkButton *button);
static guint toggle_button_signals[LAST_SIGNAL] = { 0 };
gobject_class->set_property = gtk_toggle_button_set_property;
gobject_class->get_property = gtk_toggle_button_get_property;
- widget_class->size_allocate = gtk_toggle_button_size_allocate;
widget_class->expose_event = gtk_toggle_button_expose;
- widget_class->realize = gtk_toggle_button_realize;
- widget_class->unrealize = gtk_toggle_button_unrealize;
- widget_class->map = gtk_toggle_button_map;
- widget_class->unmap = gtk_toggle_button_unmap;
button_class->pressed = gtk_toggle_button_pressed;
button_class->released = gtk_toggle_button_released;
{
toggle_button->active = FALSE;
toggle_button->draw_indicator = FALSE;
- GTK_WIDGET_UNSET_FLAGS (toggle_button, GTK_NO_WINDOW);
}
if (toggle_button->draw_indicator != draw_indicator)
{
- if (GTK_WIDGET_REALIZED (toggle_button))
- {
- gboolean visible = GTK_WIDGET_VISIBLE (toggle_button);
-
- if (visible)
- gtk_widget_hide (widget);
-
- gtk_widget_unrealize (widget);
- toggle_button->draw_indicator = draw_indicator;
-
- if (toggle_button->draw_indicator)
- GTK_WIDGET_SET_FLAGS (toggle_button, GTK_NO_WINDOW);
- else
- GTK_WIDGET_UNSET_FLAGS (toggle_button, GTK_NO_WINDOW);
-
- gtk_widget_realize (widget);
-
- if (visible)
- gtk_widget_show (widget);
- }
- else
- {
- toggle_button->draw_indicator = draw_indicator;
-
- if (toggle_button->draw_indicator)
- GTK_WIDGET_SET_FLAGS (toggle_button, GTK_NO_WINDOW);
- else
- GTK_WIDGET_UNSET_FLAGS (toggle_button, GTK_NO_WINDOW);
- }
+ toggle_button->draw_indicator = draw_indicator;
if (GTK_WIDGET_VISIBLE (toggle_button))
gtk_widget_queue_resize (GTK_WIDGET (toggle_button));
GtkStateType state_type;
gint width, height;
gboolean interior_focus;
+ gint border_width;
gint x, y;
button = GTK_BUTTON (widget);
if (GTK_WIDGET_DRAWABLE (widget))
{
+ border_width = GTK_CONTAINER (widget)->border_width;
+
gtk_widget_style_get (widget, "interior_focus", &interior_focus, NULL);
- x = 0;
- y = 0;
- width = widget->allocation.width - GTK_CONTAINER (widget)->border_width * 2;
- height = widget->allocation.height - GTK_CONTAINER (widget)->border_width * 2;
-
- gdk_window_set_back_pixmap (widget->window, NULL, TRUE);
- gdk_window_clear_area (widget->window, area->x, area->y, area->width, area->height);
+ x = widget->allocation.x + border_width;
+ y = widget->allocation.y + border_width;
+ width = widget->allocation.width - border_width * 2;
+ height = widget->allocation.height - border_width * 2;
if (GTK_WIDGET_HAS_DEFAULT (widget) &&
GTK_BUTTON (widget)->relief == GTK_RELIEF_NORMAL)
}
}
-static void
-gtk_toggle_button_size_allocate (GtkWidget *widget,
- GtkAllocation *allocation)
-{
- if (!GTK_WIDGET_NO_WINDOW (widget) &&
- GTK_WIDGET_CLASS (parent_class)->size_allocate)
- GTK_WIDGET_CLASS (parent_class)->size_allocate (widget, allocation);
-}
-
static gint
gtk_toggle_button_expose (GtkWidget *widget,
GdkEventExpose *event)
g_object_notify (G_OBJECT (toggle_button), "active");
}
-static void
-gtk_toggle_button_realize (GtkWidget *widget)
-{
- GtkToggleButton *toggle_button;
- GdkWindowAttr attributes;
- gint attributes_mask;
- gint border_width;
-
- g_return_if_fail (GTK_IS_TOGGLE_BUTTON (widget));
-
- toggle_button = GTK_TOGGLE_BUTTON (widget);
- GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
-
- border_width = GTK_CONTAINER (widget)->border_width;
-
- attributes.window_type = GDK_WINDOW_CHILD;
- attributes.x = widget->allocation.x + border_width;
- attributes.y = widget->allocation.y + border_width;
- attributes.width = widget->allocation.width - border_width * 2;
- attributes.height = widget->allocation.height - border_width * 2;
- attributes.event_mask = gtk_widget_get_events (widget);
- attributes.event_mask |= (GDK_EXPOSURE_MASK |
- GDK_BUTTON_PRESS_MASK |
- GDK_BUTTON_RELEASE_MASK |
- GDK_ENTER_NOTIFY_MASK |
- GDK_LEAVE_NOTIFY_MASK);
-
- if (GTK_WIDGET_NO_WINDOW (widget))
- {
- attributes.wclass = GDK_INPUT_ONLY;
- attributes_mask = GDK_WA_X | GDK_WA_Y;
-
- widget->window = gtk_widget_get_parent_window (widget);
- gdk_window_ref (widget->window);
-
- toggle_button->event_window = gdk_window_new (gtk_widget_get_parent_window (widget),
- &attributes, attributes_mask);
- gdk_window_set_user_data (toggle_button->event_window, toggle_button);
- }
- else
- {
- attributes.wclass = GDK_INPUT_OUTPUT;
- attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
- attributes.visual = gtk_widget_get_visual (widget);
- attributes.colormap = gtk_widget_get_colormap (widget);
- widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
- &attributes, attributes_mask);
- gdk_window_set_user_data (widget->window, toggle_button);
- }
-
- widget->style = gtk_style_attach (widget->style, widget->window);
-
- if (!GTK_WIDGET_NO_WINDOW (widget))
- gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
-}
-
-static void
-gtk_toggle_button_unrealize (GtkWidget *widget)
-{
- GtkToggleButton *toggle_button;
-
- g_return_if_fail (GTK_IS_TOGGLE_BUTTON (widget));
-
- toggle_button = GTK_TOGGLE_BUTTON (widget);
-
- if (GTK_WIDGET_NO_WINDOW (widget))
- {
- gdk_window_set_user_data (toggle_button->event_window, NULL);
- gdk_window_destroy (toggle_button->event_window);
- toggle_button->event_window = NULL;
- }
-
- if (GTK_WIDGET_CLASS (parent_class)->unrealize)
- (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
-}
-
-static void
-gtk_toggle_button_map (GtkWidget *widget)
-{
- g_return_if_fail (GTK_IS_TOGGLE_BUTTON (widget));
-
- if (GTK_WIDGET_NO_WINDOW (widget))
- gdk_window_show (GTK_TOGGLE_BUTTON (widget)->event_window);
-
- GTK_WIDGET_CLASS (parent_class)->map (widget);
-}
-
-static void
-gtk_toggle_button_unmap (GtkWidget *widget)
-{
- g_return_if_fail (GTK_IS_TOGGLE_BUTTON (widget));
-
- if (GTK_WIDGET_NO_WINDOW (widget))
- gdk_window_hide (GTK_TOGGLE_BUTTON (widget)->event_window);
-
- GTK_WIDGET_CLASS (parent_class)->unmap (widget);
-}
-
static void
gtk_toggle_button_update_state (GtkButton *button)
{
guint active : 1;
guint draw_indicator : 1;
guint inconsistent : 1;
-
- GdkWindow *event_window;
};
struct _GtkToggleButtonClass
g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
tree_view = GTK_TREE_VIEW (widget);
+
gtk_widget_style_get (widget,
"horizontal_separator", &horizontal_separator,
"vertical_separator", &vertical_separator,
if (event->window == tree_view->priv->bin_window)
return gtk_tree_view_bin_expose (widget, event);
+ else if (event->window == tree_view->priv->header_window)
+ {
+ GList *list;
+
+ for (list = tree_view->priv->columns; list != NULL; list = list->next)
+ {
+ GtkTreeViewColumn *column = list->data;
+
+ if (column->visible)
+ gtk_container_propagate_expose (GTK_CONTAINER (tree_view),
+ column->button,
+ event);
+ }
+ }
return TRUE;
}
{
GTK_WIDGET_UNSET_FLAGS (viewport, GTK_NO_WINDOW);
+ gtk_widget_set_redraw_on_allocate (GTK_WIDGET (viewport), FALSE);
gtk_container_set_resize_mode (GTK_CONTAINER (viewport), GTK_RESIZE_QUEUE);
viewport->shadow_type = GTK_SHADOW_IN;
gtk_viewport_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
- GtkViewport *viewport;
- GtkBin *bin;
+ GtkViewport *viewport = GTK_VIEWPORT (widget);
+ GtkBin *bin = GTK_BIN (widget);
GtkAllocation child_allocation;
gint hval, vval;
- gint border_width;
-
- g_return_if_fail (GTK_IS_VIEWPORT (widget));
- g_return_if_fail (allocation != NULL);
-
- widget->allocation = *allocation;
- viewport = GTK_VIEWPORT (widget);
- bin = GTK_BIN (widget);
+ gint border_width = GTK_CONTAINER (widget)->border_width;
/* demand creation */
if (!viewport->hadjustment)
if (!viewport->vadjustment)
gtk_viewport_set_hadjustment (viewport, NULL);
- border_width = GTK_CONTAINER (widget)->border_width;
+ /* If our size changed, and we have a shadow, queue a redraw on widget->window to
+ * redraw the shadow correctly.
+ */
+ if (GTK_WIDGET_MAPPED (widget) &&
+ viewport->shadow_type != GTK_SHADOW_NONE &&
+ (widget->allocation.width != allocation->width ||
+ widget->allocation.height != allocation->height))
+ gdk_window_invalidate_rect (widget->window, NULL, FALSE);
+
+ widget->allocation = *allocation;
child_allocation.x = 0;
child_allocation.y = 0;
if (viewport->shadow_type != GTK_SHADOW_NONE)
{
- child_allocation.x = GTK_WIDGET (viewport)->style->xthickness;
- child_allocation.y = GTK_WIDGET (viewport)->style->ythickness;
+ child_allocation.x = widget->style->xthickness;
+ child_allocation.y = widget->style->ythickness;
}
child_allocation.width = MAX (1, allocation->width - child_allocation.x * 2 - border_width * 2);
break;
}
+ x += widget->allocation.x;
+ y += widget->allocation.y;
+
state_type = GTK_STATE_NORMAL;
if (!GTK_WIDGET_IS_SENSITIVE (scale))
state_type = GTK_STATE_INSENSITIVE;
gint *eventp;
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (!GTK_WIDGET_NO_WINDOW (widget));
g_return_if_fail (!GTK_WIDGET_REALIZED (widget));
eventp = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_event_mask);
gint *eventp;
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (!GTK_WIDGET_NO_WINDOW (widget));
-
+
eventp = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_event_mask);
if (events)
if (GTK_WIDGET_REALIZED (widget))
{
- gdk_window_set_events (widget->window,
- gdk_window_get_events (widget->window) | events);
+ if (GTK_WIDGET_NO_WINDOW (widget))
+ {
+ GList *children = gdk_window_get_children (widget->window);
+ GList *tmp_list = children;
+
+ while (tmp_list)
+ {
+ GdkWindow *window = tmp_list->data;
+ gpointer user_data;
+
+ gdk_window_get_user_data (window, &user_data);
+ if (user_data == widget)
+ gdk_window_set_events (window, gdk_window_get_events (window) | events);
+ }
+ }
+ else
+ {
+ gdk_window_set_events (widget->window, gdk_window_get_events (widget->window) | events);
+ }
}
g_object_notify (G_OBJECT (widget), "events");
projects / gtk4.git / commitdiff